home *** CD-ROM | disk | FTP | other *** search
/ LOGIC Apps / Logic-APPLE_II_APPS.iso / mac / LOGIC Apple II 5.25" Library - ProDOS / PRO031.dsk / F.DISK.txt < prev    next >
Text File  |  2012-02-16  |  90KB  |  1 lines

  1. ( SYSTEM INSTALLATION )                        ( 24 JAN 86 JBM )                                                                ( LOAD THIS SCREEN TO SAVE THE CURRENT DICTIONARY TO DISK )                                                                     BASE @ FORTH DEFINITIONS HEX                                                                                                    LATEST     0C +ORIGIN ! ( TOP NFA )                             HERE       1C +ORIGIN ! ( INITIAL FENCE VALUE )                 HERE       1E +ORIGIN ! ( DICTIONARY POINTER )                  VOC-LINK @ 20 +ORIGIN ! ( VOCABULARY LINK )                                                                                     HERE FENCE ! ( UPDATE THE CURRENT FENCE )                                                                                       SAVE F.DICT  ( SAVE THE NEW DICTIONARY )                                                                                        BASE ! ;S                                                       ( GOING FORTH CAI COURSE )                     ( 23 MAY 80 DRC )( MODIFIED FOR APPLE-DAYTON PRO FORTH            14 MAR 86 JBM )                                                                FORTH DEFINITIONS BASE @ DECIMAL                                                                                                 64 CONSTANT B/L             0 VARIABLE LN(1)                    16 CONSTANT L/P           L/P VARIABLE LN(2)                     6 CONSTANT FIRST-SCREEN    0 VARIABLE CURRENT-SCREEN                                                                          : EXIT  ;S ( 79-STD ) ;                                                                                                         : GET-LINE   ( LINE --- ADDR )                                     B/L B/BUF */MOD CURRENT-SCREEN @ B/SCR * + BLOCK + ;                                                                         -->                                                                                                                             ( GOING FORTH CAI COURSE )                     ( 23 MAY 80 DRC )( ADD HOME TO VIEW AND FIXED WHAT                14 MAR 86 JBM )                                                                : VIEW -936 CALL CURRENT-SCREEN !                                 LN(2) @ LN(1) @ DO I GET-LINE B/L -TRAILING TYPE CR LOOP ;                                                                    : WHAT CURRENT-SCREEN @ VIEW QUIT ;                                                                                             : BACKUP CURRENT-SCREEN @ 1 - VIEW QUIT ;                                                                                       : GO CURRENT-SCREEN @ 1 + VIEW QUIT ;                                                                                           -->                                                                                                                                                                                                                                                             ( CAI ASSIST WORDS )                           ( 30 NOV 80 DRC ): S? ( STACK PRINT ) S. ;                                       : GOT-IT 2 CURRENT-SCREEN +! WHAT ;                             : 'FRAME  FIRST-SCREEN + ;                                      : FRAME 'FRAME VIEW QUIT ;                                      : CONTENTS 'FRAME SWAP 'FRAME SWAP 1+ SWAP                        DO CR 0 I .LINE ?TERMINAL IF LEAVE THEN LOOP ;                : SEE 'FRAME CURRENT-SCREEN @ SWAP VIEW CURRENT-SCREEN ! QUIT ; : NOTHING ;                                                                                                                     : HELLO SP! DR0 DECIMAL [COMPILE] FORTH DEFINITIONS                0 'FRAME CURRENT-SCREEN ! WHAT ;                                                                                             HEX ' HELLO 100 /MOD 180D C! 1811 C!                                                                                            BASE !                                                          Not defined in this context                                     Stack empty                                                     Dictionary full                                                 Assembler addressing mode undefined                             Redefined                                                       5                                                               6                                                               Stack full                                                      ProDOS MLI error during R/W                                     ProDOS MLI error during CLOSE                                   ProDOS MLI error during OPEN                                    ProDOS MLI error during SAVE                                    ProDOS MLI error during GET.BLK                                 13                                                              14                                                              Adapted for ProDOS by John B. Matthews, M.D.                    String not found                                                Permitted only in compilation                                   Permitted only in execution                                     Conditional not paired                                          Definition not finished                                         Can't be forgotten                                              Use only when LOADing                                           Line # outside editor range                                     Single character expected                                       25                                                              26                                                              27                                                              28                                                              29                                                              30                                                              31                                                              ***************************************                         *                                     *                         *          ' GOING FORTH '            *                         *                                     *                         *         A COMPUTER-AIDED            *                         *        INSTRUCTION COURSE           *                         *                                     *                         *              FROM                   *                         *                                     *                         *         CREATIVE SOLUTIONS          *                         *         4801 RANDOLPH ROAD          *                         *        ROCKVILLE, MD  20852         *                         *                                     *                         ***************************************                                                                                              TYPE GO TO CONTINUE.                                       FRAME #1 WELCOME TO GOING FORTH                                                                                                      THIS SYSTEM HAS BEEN DESIGNED TO HELP YOU LEARN THE        FUNDAMENTAL CONCEPTS OF THE PROGRAMMING APPROACH KNOWN AS FORTH.                                                                     INITIALLY WRITTEN BY CHARLES MOORE OVER 10 YEARS AGO, FORTHREPRESENTS A FOURTH GENERATION COMBINATION OF PROVEN PROGRAMMINGPRACTICES GIVING PERHAPS THE MOST POWERFUL PROGRAMMING APPROACH EVER CREATED. THIS COURSE IS ORGANIZED INTO FOUR LESSONS, EACH  LESSON EXPLORING A BASIC CONCEPT OF FORTH.                                                                                           AT THE CONCLUSION OF THIS COURSE, WE WILL ATTEMPT OUR FIRSTFORTH PROGRAM.                                                                                                                       TYPE GO TO CONTINUE.                                                                                                       FRAME #2 MY INTENTIONS SIR?                                          WE HAVE ADOPTED A SOMEWHAT FRISKY APPROACH TO THE          PRESENTATION OF THE FOLLOWING MATERIAL. THIS IS DUE TO OUR FIRM BELIEF, HOWEVER CONTRARY TO THAT HELD BY MOST CONTEMPORARY      EDUCATIONAL INSTITUTIONS, LEARNING A NEW COMPUTER LANGUAGE CAN  AND SHOULD BE FUN! THE ONLY TOOLS REQUIRED TO COMPLETE THIS     COURSE ARE YOUR NATURAL CREATIVE AND INTUITIVE TALENTS, AND A   HUMANE POSTURE TOWARDS OUR OBVIOUS HUMAN WEAKNESES. ONE FURTHER CAUTION, THE POWER OF FORTH IS DERIVED PRIMARILY FROM THE UNIQUECOMBINATION OF A GROUP OF VERY SIMPLE CONCEPTS.                                                                                      BE CAREFUL NOT TO LET YOUR BACKGROUND COMPLICATE A         FUNDAMENTALLY SIMPLE CONCEPT OR DISCOUNT ITS VALUE. IN FORTH,   POWER IS A PRODUCT OF SIMPLICITY.                                                                                                    TYPE GO TO CONTINUE.                                       FRAME #3 COARSE OUTLINE                                          I. BACK TO BASICS                                                 - COMMUNICATING BACK & FORTH (INTRODUCTION)                     - BUT WORDS WILL NEVER HURT YOU (WHAT FORTH EXPECTS)            - HEY, STACKS! (THE CONCEPT OF A STACK)                         - MATH MYTHS (ARITHMETIC OPERATORS)                           II. DEFINITIONS - MY WORD!                                           (BUILDING YOUR OWN WORDS)                                     - LIFE WITHOUT GOTO (BLOCK STRUCTURED LOGIC)                    - VARIABLE CONSTANTS (DATA STRUCTURES)                       III. PROGRAM ENTRY AND DISPLAY -                                    RAPTURE CAPTURE (TEXT EDITOR) -                                 RAPTURE, RAPTURE, RAPTURE ( PRINTING UTILITIES)             IV. PROGRAM DEVELOPMENT                                                                                                         TYPE GO TO CONTINUE.                                           FRAME #4   THE OPPOSITE OF GO IS BACKUP                                                                                              SO FAR YOU'VE LEARNED THAT THE WORD 'GO' WILL MOVE ON TO   THE NEXT FRAME. SUPPOSE YOU WANT TO GO BACK TO THE PREVIOUS     FRAME TO REVIEW. INSTEAD OF TYPING 'GO' ENTER 'BACKUP'                                                                               GO AHEAD AND TRY IT NOW. YOU CAN ALWAYS 'GO' FORWARD AND   'BACKUP' TO GET TO WHERE YOU LEFT OFF.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               WHEN YOU'RE FINISHED 'GO' ON...                            FRAME #5 LESSON 1 - BACK TO BASICS                                                                                               - COMMUNICATING BACK & FORTH (INTRODUCTION)                     - BUT WORDS WILL NEVER HURT YOU ( WHAT FORTH EXPECTS)           - HEY, STACKS! (THE CONCEPT OF A STACK)                         - MATH MYTHS (ARITHMETIC OPERATORS)                                                                                                THE OBJECTIVE OF THIS LESSON IS TO INTRODUCE YOU TO THE     ENVIRONMENT IN WHICH FORTH OPERATES.                                                                                                ENTER 'GO' TO CONTINUE.                                                                                                                                                                                                                                                                                                                                                                     FRAME #6 I'M OK YOU'RE OK                                                                                                            THE KEYBOARD PROVIDES YOU WITH A CONVENIENT WAY TO         COMMUNICATE WITH FORTH, WHILE THE DISPLAY IS FORTH'S WAY TO     COMMUNICATE WITH YOU. YOU MUST TERMINATE YOUR REQUEST TO FORTH  BY ENTERING THE (CR). THIS INFORMS FORTH THAT YOU WANT YOUR     REQUEST PROCESSED.                                                                                                                   FORTH THEN PROCESSES YOUR REQUEST AND RESPONDS WITH 'OK'.  IF FORTH IS UNABLE TO PROCESS YOUR REQUEST, THE WORD IN QUESTIONIS PRINTED FOLLOWED BY A '?', AND OFTEN THE REASON WHY.                                                                              FOR EXAMPLE, ENTER JUST (CR) AND SEE FORTH MERRILY         ACKNOWLEDGE YOUR REQUEST TO DO NOTHING WITH 'OK'.                                                                                    LET'S 'GO' ON.                                             FRAME #7 WHEN FORTH DOES NOT UNDERSTAND                                                                                             FORTH IS GENERALLY VERY UNDERSTANDING. THAT IS, UNTIL YOU   IMPROPERLY ENTER A REQUEST.                                                                                                         FOR EXAMPLE, MISSPELL 'WHAT' WHILE ENTERING IT BELOW ( LIKE 'WHUT'). SINCE FORTH WASN'T ABLE TO PERFORM YOUR REQUEST, IT    PRINTED YOUR MISSPELLED WORD AND A '?' AND IS WAITING FOR       ANOTHER TRY. SPELL IT RIGHT, AND FORTH WILL COMPLY.                                                                                 LETS 'GO' ON.                                                                                                                                                                                                                                                                                                                                                                               FRAME #8 IF AT FIRST YOU DON'T SUCCEED                               IT IS IMPORTANT TO MENTION THE NON-VOLATILITY OF FORTH.    FORTH ALLOWS YOU TO MAKE MOST MISTAKES WITHOUT CAUSING ANY      SIGNIFICANT CHANGE TO THE SYSTEM.                                                                                                    WHEN A REQUEST IS ENTERED IMPROPERLY, FORTH LETS YOU       KNOW BY PRINTING YOUR REQUEST BACK, ALONG WITH A '?' AND AN ERROMESSAGE. SIMPLY RE-ENTER IT UNTIL YOU GET IT RIGHT, WHICH FORTH ACKNOWLEDGES BY 'OK'.                                                                                                                THE BACKSPACE OR DELETE KEY ALLOWS THE CAPABILITY TO       CORRECT ANY INCORRECT CHARACTER(S). TRY IT OUT BY TYPING        SEVERAL CHARACTERS BELOW AND BACKSPACING THEM AWAY.                                                                                  LET'S 'GO' ON TO DISCUSS HOW FORTH EXPECTS YOU TO MAKE     REQUESTS.                                                       FRAME #9 GREAT EXPECTATIONS                                                                                                          FORTH EXPECTS YOU TO ENTER YOUR REQUEST AS A SERIES OF     WORDS. A WORD TO FORTH IS JUST A STRING OF CHARACTERS SEPARATED BY AT LEAST ONE SPACE OR THE CARRIAGE RETURN (CR).                                                                                   FOR EXAMPLE:                                                         ENTER -> NOTHING NOTHING NOTHING                                                                                           FOR THE PURPOSES OF THIS EXAMPLE, THE WORD 'NOTHING' IS    DEFINED TO DO NOTHING, SO FORTH QUITE HAPPILY DID NOTHING THREE TIMES. GO AHEAD AND ENTER 'CR' A COUPLE OF TIMES ON THE SAME    LINE. ENTER 'WHAT' TO THIS SCREEN AGAIN.                                                                                                                                                             WHEN YOU'RE TIRED OF THIS, ENTER 'GO'.                     FRAME #10 YOU'RE AS GOOD AS YOUR 'WORD'                                                                                              A WORD MAY HAVE A MAXIMUM OF 31 CHARACTERS. YOU MAY WANT TOINCLUDE MORE THAN ONE SPACE BETWEEN WORDS FOR CLARITY BUT YOU   MUST HAVE AT LEAST ONE SPACE.                                                                                                        LET'S ENTER SOMETHING THAT FORTH DOESN'T UNDERSTAND:                                                                            ENTER -> SOMETHING                                                                                                              IT SHOULD BE APPARENT THAT THE WORD 'SOMETHING' IS UNKNOWN TO FORTH. WE WILL LEARN HOW TO CREATE NEW WORDS IN LATER FRAMES.                                                                     PLEASE 'GO' ON.                                                                                                                                                                            FRAME #11 THE NUMBERS GAME                                                                                                           A NUMBER IS JUST LIKE ANY OTHER WORD TO FORTH. WHEN WE     REFER TO NUMBERS, WE MEAN WHOLE NUMBERS, BOTH POSITIVE AND      NEGATIVE. WHEN A WORD IS ENTERED, FORTH EXAMINES IT FOR         PROCESSING. IF IT IS A NUMBER, FORTH WILL HOLD ONTO IT AND SAY  'OK'. LET'S ENTER A NUMBER:                                                                                                               ENTER -> 5                                                                                                                 WHERE IS OUR NUMBER?                                                                                                            PLEASE 'GO' ON.                                                                                                                                                                                                                                            FRAME #12 I'VE GOT YOUR NUMBER                                       A NUMBER MAY BE DISPLAYED NUMEROUS WAYS. THE WORD CALLED   DOT, ALWAYS ENTERED AS '.', ALLOWS YOU TO PRINT THE NUMBER MOST RECENTLY ENTERED. PRINTING A NUMBER REMOVES THE NUMBER          PERMANENTLY FROM THE STACK. LET'S PRINT THE NUMBER WHICH WE     ENTERED IN THE PRIOR FRAME.                                                                                                               ENTER -> .                                                                                                                 CONSIDER ANOTHER EXAMPLE:                                                                                                            ENTER -> 6 . 7 .                                                                                                           WE MAY COMBINE MULTIPLE REQUESTS ON A SINGLE LINE. REMEMBERTO INCLUDE AT LEAST ONE SPACE BETWEEN WORDS.                         PLEASE 'GO' FORTH.                                         FRAME #13 THE CONCEPT OF A STACK                                                                                                     WHEN FORTH HOLDS ONTO A NUMBER, IT STACKS THEM ONE ON TOP  OF THE OTHER SIMILAR TO A STACK OF PLATES IN A CAFETERIA. IF YOUPLACE 3 PLATES ONE ON TOP OF THE OTHER, AND THEN REACH FOR ONE, THE TOP PLATE, (OR LAST ONE STACKED) IS THE EASIEST TO PICK UP. TRY STACKING THREE NUMBERS:                                                                                                               ENTER - > 1 2 3                                                                                                            THESE NUMBERS ARE STORED ON A STACK THAT LOOKS LIKE THIS: 32 1                                                                                                                                  LETS 'GO' ON TO DISCUSS HOW WE REMOVE THESE NUMBERS FROM   THE STACK.                                                                                                                      FRAME #14 LET'S TAKE IT FROM THE TOP                                 WHEN YOU ENTER NUMBERS, THEY ARE PLACED ON A STACK. FORTH  ALWAYS ACTS ON THE TOP OF THE STACK FIRST. THEREFORE, THE LAST  NUMBER ENTERED IS THE FIRST NUMBER PRINTED.                                                                                          LET'S PRINT THE THREE NUMBERS THAT WE STACKED IN THE PRIOR FRAME. (REMEMBER TO INCLUDE SPACES BETWEEN WORDS!)                                                                                        ENTER - > . . .                                                                                                            AGAIN, NOTICE THAT THE '3' WAS THE LAST NUMBER STACKED AND,THEREFORE, THE FIRST PRINTED. FURTHERMORE, SINCE THE 'DOT'      COMMAND REMOVES THE NUMBER FROM THE STACK, OUR STACK IS NOW     EMPTY.                                                                                                                               PLEASE 'GO' ON.                                            FRAME #15 LIVING WITHIN YOUR MEANS                                                                                                   FOR ALL PRACTICAL PURPOSES, THE STACK CAN BE CONSIDERED TO BE ENDLESS. FORTH WILL INFORM YOU IF YOU TRY TO REMOVE SOMETHINGFROM AN EMPTY STACK, OR IN THE UNLIKELY EVENT OF IT BECOMING    FULL. SO, DON'T BE SUPRISED TO SEE GARBAGE WHEN YOU ASK FOR     SOMETHING THAT DOESN'T EXIST.                                                                                                        PLEASE 'GO' ON.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FRAME #16 DON'T BLOW YOUR STACK                                      YOU CAN NOT REMOVE MORE NUMBERS FROM THE STACK THAN YOU PUTON. IN THE EVENT THAT YOU TRY, FORTH INFORMS YOU THAT YOU'VE    BLOWN YOUR STACK!                                                                                                                    LET'S INTENTIONALLY BLOW OUR STACK BY TRYING TO PRINT MORE NUMBERS THAN WE PUT ON.                                                                                                                   ENTER -> 1 2 3 . . . .                                                                                                     WE PLACED THREE NUMBERS ON THE STACK, BUT ATTEMPTED TO     REMOVE FOUR. FORTH PRINTED WHAT WAS ON THE STACK. UNABLE TO     PERFORM THE LAST '.', FORTH PRINTED GARBAGE, EXPLAINING THAT THESTACK WAS EMPTY.                                                                                                                     PLEASE 'GO' ON.                                            FRAME #17 THE FACTS OF LIFO                                                                                                          IT IS IMPORTANT TO REMEMBER THAT THE LAST NUMBER ENTERED ISTHE FIRST NUMBER PROCESSED. THAT'S LIFO! (LAST IN FIRST OUT).                                                                        SUPPOSE WE ENTER MULTIPLE REQUESTS ON A SINGLE LINE. DOES  AN ERROR IN ONE OF THE REQUESTS STOP FURTHER PROCESSING OF THE  FOLLOWING REQUESTS? YES! CONSIDER AN EXAMPLE:                                                                                             ENTER -> 1 2 . . . 3 . 4 .                                                                                                 FORTH PROCESSES THIS REQUEST UNTIL AN ERROR IS ENCOUNTERED.AT THIS POINT, FORTH TERMINATES ANY FURTHER PROCESSING OF THE   SUCCEEDING REQUESTS.                                                                                                                 PLEASE 'GO' ON.                                            FRAME #18 SMART 'S?'                                                                                                                 SUPPOSE WE WANTED TO SEE THE CONTENTS OF THE STACK. WE     COULD USE THE WORD '.', BUT THAT WOULD DESTROY THEM. 'S?'       DISPLAYS THE CONTENTS OF THE STACK AND INFORMS YOU WHEN IT IS   EMPTY.                                                                                                                                    ENTER -> 1 2 3 4 5 S?                                                                                                      'S?' IS A VERY USEFUL COMMAND. IT MAY BE USED AT ANY TIME  TO VERIFY THE CONTENTS OF THE STACK. LET'S CLEAR OUR STACK:                                                                               ENTER -> . . . . .                                                                                                         OUR STACK SHOULD BE EMPTY. VERIFY THIS WITH S?                  PLEASE 'GO' FORTH.                                         FRAME #19 FORTH AND ARITHMETIC                                                                                                       FORTH WORKS WITH WHOLE NUMBERS ONLY. THE CONVENTIONAL      OPERATORS ARE '+' FOR ADD, '-' FOR SUBTRACT, '*' FOR MULTIPLY,  AND '/' FOR DIVIDE. FORTH ACTS ON THE MOST RECENTLY ENTERED     NUMBER FIRST AND THEN THE SECOND MOST RECENTLY ENTERED NUMBER ONTHE STACK. THESE NUMBERS ARE REMOVED FROM THE STACK, THE        OPERATION IS PERFORMED, AND THE RESULT IS PLACED ON THE TOP OF  THE STACK (TOS).                                                                                                                     LET'S 'GO' ON TO DISCUSS ADDITION.                                                                                                                                                                                                                                                                                                                                                         FRAME #20 SUM TIMES                                                  WHEN FORTH PERFORMS ADDITION, IT REMOVES THE TOP TWO ITEMS FROM THE STACK, ADDS THEM TOGETHER, AND PLACES THE SUM ON THE   TOP OF THE STACK. FOR EXAMPLE, TO ADD '5' AND '6':                                                                                         ENTER - > 5 6 +                                                                                                            THE CONTENTS OF THE STACK IS NOW '11'. VERIFY THIS WITH S?LET'S ADD '4' TO THIS VALUE AND PRINT THE SUM:                                                                                             ENTER -> 4 + .                                                                                                             FORTH REMOVED THE '11' AND '4', ADDED THEM TOGETHER, AND  PLACED THE SUM ON THE TOS. FORTH THEN PRINTED THE '15' AND      REMOVED IT FROM THE STACK.                                            LET'S 'GO' ON TO SUBTRACTION.                             FRAME #21 WHAT'S THE DIFFERENCE                                                                                                      FORTH SUBTRACTS THE NUMBER ON THE TOS FROM THE NUMBER      BENEATH IT. IT IS SIMPLER THAN IT SOUNDS. THE NOTATION FOR '8   MINUS 6' IS '8 6 -'. FOR EXAMPLE:                                                                                                         ENTER -> 8 6 - .                                                                                                           THE '6' AND '8' ARE REMOVED FROM THE STACK. THE '6' IS     SUBTRACTED FROM '8'. THE DIFFERENCE '2' IS RETURNED TO THE STACKUNTIL YOU PRINT IT. REMEMBER, PRINTING A NUMBER REMOVES IT FROM THE STACK.                                                                                                                          LET'S 'GO' ON TO MULTIPLICATION.                                                                                                                                                            FRAME #22 GO FORTH AND MULTIPLY                                      MULTIPLICATION IS QUITE SIMPLE. THE NOTATION FOR '2 TIMES  3' IS '2 3 *'.                                                                                                                            ENTER -> 2 3 *                                                                                                             WE GET A '6' ON THE TOS. LET'S VERIFY THESE RESULTS WITHOUTDESTROYING THE CONTENTS OF THE STACK FOR OUR NEXT EXAMPLE:                                                                                ENTER -> S?                                                NOW LET'S MULTIPLY THE TOS BY '4'.                                   ENTER -> 4 * .                                                                                                             THE RESULT IS '24'. THE '6' ON THE STACK IS MULTIPLIED BY  THE '4' WE ENTERED. DIVISION IS A BIT MORE COMPLICATED.              PLEASE 'GO' ON.                                            FRAME #23 THE GREAT DIVIDE                                           FORTH DIVIDES THE NUMBER ON THE TOS INTO THE NUMBER BENEATHIT. THE NOTATION FOR '12 DIVIDED BY 6' IS '12 6 /'. FOR EXAMPLE:                                                                          ENTER -> 12 6 / .                                                                                                          THE RESULT IS '2' SINCE '12' IS EVENLY DIVIDED BY '6'.     SINCE FORTH ONLY WORKS WITH WHOLE NUMBERS, THE RESULT OF THE    DIVISION IS TRUNCATED TO A WHOLE NUMBER. FOR EXAMPLE:                                                                                     ENTER -> 15 6 / .                                                                                                          THE RESULT IS ALSO '2'. SUPPOSE WE NEEDED TO KNOW THE      REMAINDER IN A DIVISION PROBLEM?                                                                                                     'GO' ON TO FIND OUT.                                       FRAME #24 IT'S A MOD, MOD WORLD                                                                                                      WE CAN RETAIN THE REMAINDER IN A DIVISION PROBLEM BY USING 'MOD'. THE NOTATION IS SIMILAR TO DIVISION. WE OBTAIN THE       REMAINDER OF '15 DIVIDED BY 6' AS FOLLOWS:                                                                                                 ENTER -> 15 6 MOD .                                                                                                       THIS PRODUCES A '3'. SUPPOSE WE NEEDED TO KNOW BOTH THE    REMAINDER AND THE QUOTIENT?                                                                                                          LET'S 'GO' ON TO SEE HOW THIS IS ACCOMPLISHED.                                                                                                                                                                                                                                                                             FRAME #25 TWO FOR THE PRICE OF ONE                                                                                                   IN OUR DISCUSSION OF DIVISION, WE USED '/' TO FIND THE     QUOTIENT, AND 'MOD' TO FIND THE REMAINDER. TO FIND BOTH WE USE  '/MOD'. FOR EXAMPLE:                                                                                                                 ENTER -> 15 6 /MOD . .                                                                                                          THIS RETURNS THE QUOTIENT TO THE TOS AND THE REMAINDER     BENEATH IT.                                                                                                                          LET'S 'GO' ON TO COMBINE SOME OF THE ARITHMETIC OPERATIONS.                                                                                                                                                                                                                                                                FRAME #26 THAT SUMS IT UP                                            UP TO THIS POINT, THE ARITHMETIC OPERATIONS WERE HANDLED   ONE BY ONE. WHAT HAPPENS WHEN OPERATIONS ARE COMBINED?                                                                                    ENTER -> 2 4 6 + * .                                                                                                       REMEMBER, FORTH ACTS ON THE MOST RECENTLY ENTERED NUMBER   FIRST THEN THE SECOND MOST RECENTLY ENTERED NUMBER. THE NUMBERS ARE STACKED IN THE INPUT ORDER UNTIL THE FIRST OPERATOR, '+',   IS ENCOUNTERED. THE '4' AND '6' ARE ADDED TOGETHER, AND THE     RESULT '10' IS NOW ON THE TOP OF THE STACK, WITH THE '2' STILL  BENEATH IT. '*' MULTIPLIES '2' BY '10' AND LEAVES THE CONTENTS  OF THE STACK AS '20'. LETS TRY THE EXAMPLE ( 4+6 ) / 2 :                                                                                  ENTER -> 4 6 + 2 / .                                       LET US 'GO' ON TO LEARN HOW TO MANIPULATE THE STACK.       FRAME #27 GIVE AND YE SHALL RECIEVE                                  NOW THAT OUR FORTH VOCABULARY IS GROWING, WE MAY NEED SOME HELP IN REMEMBERING THE DEFINITION OF A WORD THAT WAS EXPLAINED A FEW FRAMES BACK. IF THIS WERE A BOOK, WE WOULD FLIP THROUGH   THE TABLE OF CONTENTS FOR A HANDY REFERENCE, OR WE WOULD CHECK  THE GLOSSARY FOR ITS DEFINITION. TAKE YOUR PICK, WE HAVE        PROVIDED BOTH.                                                                                                                       THE FRAME TABLE OF CONTENTS CAN BE SEEN BY GIVING A        STARTING FRAME# AND AN ENDING FRAME# AND THE WORD 'CONTENTS'.                                                                        LET'S LOOK AT THE TITLES OF THE FIRST SEVEN FRAMES:                                                                                  ENTER -> 1 7 CONTENTS                                                                                                      LET'S 'GO' ON.                                             FRAME #28 A SECOND HELPING                                                                                                           TO SEE A PARTICULAR FRAME, WITHOUT LOOSING YOUR PLACE,     ENTER THE FRAME NUMBER YOU WANT AND THE WORD 'SEE'. THE WORD    'WHAT' WILL RE-DISPLAY THE FRAME WHERE YOU LEFT OFF. TO ACTUALLYMOVE TO A NEW FRAME, ENTER THE FRAME NUMBER AND THE WORD        'FRAME'                                                                                                                              FOR REFERENCE, THE STANDARD FORTH WORDS WITH THEIR         DEFINITIONS AND STACK EFFECTS ARE COLLECTED TOGETHER IN A       GLOSSARY. THE PRO FORTH GLOSSARY IS IN A TEXT FILE ON ONE OF    THE DISKS IN THIS SET. IT IS VERY USEFUL TO PRINT THIS FILE     AND KEEP IT HANDY FOR FUTURE REFERNCE.                                                                                                                                                               PLEASE 'GO' ON.                                            FRAME #29 OPERATOR, GIVE ME INFORMATION                                                                                              THE FOLLOWING IS A LIST OF WORDS THAT MANIPULATE THE STACK:                                                                   DUP     COPIES TOP OF THE STACK                                 SWAP    REVERSES TOP 2 NUMBERS ON THE STACK                     DROP    DESTROYS TOP NUMBER ON STACK                            OVER    COPIES 2ND NUMBER TO TOP OF STACK                       ROT     MOVES 3RD NUMBER TO TOP OF STACK                        ABS     ABSOLUTE VALUE OF TOP OF STACK                          MAX     SAVES ONLY THE LARGER OF THE TOP 2 NUMBERS              MIN     SAVES ONLY THE SMALLER OF THE TOP 2 NUMBERS                                                                               NOW LET'S PUT SOME OF THESE MANIPULATORS TO USE. PLEASE    'GO' FORTH.                                                                                                                     FRAME #30 FAST OPERATORS                                              LET'S TRY SOME OF THESE STACK OPERATORS. 'DUP' COPIES THE TOP OF THE STACK. FOR EXAMPLE:                                                                                                            ENTER -> 5 DUP . .                                                                                                         'SWAP' REVERSES THE TOP TWO NUMBERS ON THE STACK. FOR      EXAMPLE:                                                                                                                                  ENTER -> 8 4                                                                                                               LET'S PRINT THEM BEFORE AND AFTER THE 'SWAP':                                                                                        ENTER -> S? SWAP S?                                        NOW CLEAR THE STACK: ENTER -> . .                               PLEASE 'GO' ON.                                            FRAME #31 DROP OVER & ROT                                            NOW WE CAN TRY SOME OF THE OTHER STACK OPERATORS.                                                                                    ENTER -> 2 3 DROP .                                                                                                        THE RESULT IS '2', SINCE WE DROPPED THE TOP OF THE STACK   '3'.                                                                                                                                      ENTER -> 5 10 OVER . . .                                                                                                   WE NOW GET '5 10 5', SINCE THE SECOND NUMBER WAS COPIED TO THE TOP OF THE STACK. THE 'ROT' OPERATOR ROTATES THE 3RD NUMBER TO THE TOP OF THE STACK.                                                                                                                  ENTER -> 2 4 6 ROT . . .                                   WE GET '2 6 4'. PLEASE 'GO' ON.                            FRAME #32 COMBOS                                                                                                                     AFTER WE BECOME FAMILIAR WITH BOTH THE ARITHMETIC OPERATORSAND THE STACK MANIPULATORS, WE WILL BE ABLE TO CREATE OUR OWN   COMBINATIONS. LET'S DOUBLE A NUMBER:                                                                                                      ENTER -> 3 DUP + .                                                                                                         OR,SQUARE A NUMBER:                                                                                                                  ENTER -> 3 DUP * .                                                                                                         LET'S 'GO' ON TO DISCUSS A MORE CONVENIENT WAY TO USE THE  STACK OPERATIONS.                                                                                                                                                                               FRAME #33 LESSON 1 - SUMMARY                                         SIT BACK AND RELAX! THIS IS A GOOD POINT TO TAKE A         BREAK, AND CONSIDER WHAT HAS BEEN PRESENTED. YOU SHOULD NOW BE  FAMILIAR WITH THE FOLLOWING CONCEPTS:                                                                                              - HOW FORTH EXPECTS YOU TO ENTER REQUESTS                       - WHAT FORTH DOES WHEN IT DOES NOT UNDERSTAND A REQUEST         - ENTRY AND DISPLAY OF NUMBERS                                  - THE CONCEPT OF A STACK                                        - FORTH'S APPROACH TO ARITHMETIC                                - STACK MANIPULATION OPERATORS                                  - HOW TO ASK FOR AND RECEIVE HELP                                                                                                 IF YOU DO NOT FULLY UNDERSTAND ANY OF THE ABOVE CONCEPTS,  'GO' ON AND YOU WILL BE SHOWN HOW TO GO BACK AND REPEAT A       SECTION, OTHERWISE ENTER 'GOT-IT' AND WE WILL GO ON TO LESSON 2.FRAME #34 LESSON 1 - REVIEW                                          WE WILL REVIEW THE FRAME TITLES FOR LESSON 1. SELECT THE   TITLE WHICH IS IN THE AREA WHICH YOU WOULD LIKE TO REVIEW AND   ENTER THE FRAME NUMBER WHEN REQUESTED. THIS WILL RESTART THE    PRESENTATION ON THAT FRAME. FEEL FREE TO CREATE YOUR OWN        EXAMPLES TO HELP IN UNDERSTANDING. TO REVIEW LESSON 1 TITLES:                                                                             ENTER -> 0 33 CONTENTS                                                                                                     YOU MAY HIT A RETURN TO STOP THE DISPLAY WHEN YOU SEE      THE FRAME TITLE YOU WISH TO REVIEW.                                  TO RESTART THE LESSON AT THAT FRAME:                                 ENTER -> FRAME# AND THE WORD 'FRAME'                       FOR EXAMPLE: 10 FRAME                                           THIS WILL CAUSE YOU TO START REVIEWING FROM THE DESIRED    POINT.                                                          FRAME #35 LESSON 2 - DEFINITIONS                                                                                                 - MY WORD! (IN YOUR OWN WORDS)                                    - LIFE WITHOUT GOTO                                               (BLOCK STRUCTURED LOGIC)                                                                                                      - VARIABLE CONSTANTS                                              (DATA STRUCTURES)                                                                                                               THE OBJECTIVE OF THIS LESSON IS TO INTRODUCE THE CONCEPT OFEXTENSIBILITY AS THE PRIMARY METHOD OF WRITING FORTH PROGRAMS.                                                                       ENTER 'GO' TO PROCEED.                                                                                                                                                                                                                                     FRAME #36 QUOTABLE QUOTES                                                                                                            FORTH PROVIDES YOU WITH A WAY TO PRINT LITERALS BY USING   THE 'DOT-QUOTE' WORD (PERIOD QUOTATION MARKS). THE QUOTE WORD ISFOLLOWED BY EXACTLY 1 SPACE, AND THEN THE TEXT. THE END OF THE  TEXT IS DELIMITED BY A QUOTATION MARK.                                                                                               FOR EXAMPLE, TO PRINT A NAME:                                                                                                        ENTER -> ." JOE FORTH, IV"                                                                                                 ENTERING THE (CR) CAUSED THE TEXT TO EXECUTE IMMEDIATELY.                                                                       LET'S 'GO' ON.                                                                                                                                                                             FRAME #37 I SHALL RETURN                                                                                                             SUPPOSE WE WANTED TO PRINT TEXT ON SEVERAL LINES. WE USE   'CR' (CARRIAGE RETURN) TO DO THIS. 'CR' WILL RETURN THE CARRIAGETO THE LEFT MARGIN AND DOWN 1 LINE.                                                                                                  THE WORD 'SPACES' IS ALSO USED IN FORMATTING TO INSERT     SPACES BETWEEN TEXT. LET'S CREATE AN INVENTORY REPORT. CONSIDER THE FOLLOWING EXAMPLE TO PRINT THE COLUMN HEADERS:                                                                                   ENTER -> CR ." STOCK #" 10 SPACES ." DESCRIPTION" CR                                                                            LET'S 'GO' ON.                                                                                                                                                                                                                                             FRAME #38 WHAT'S IN A NAME?                                          FORTH'S POWER LIES IN ITS ABILITY TO DEFINE NEW WORDS.                                                                          SUPPOSE YOU FREQUENTLY WANT TO ADD TWO NUMBERS AND PRINT   THE SUM. INSTEAD OF ALWAYS TYPING '+' AND '.' FOR EACH          OPERATION, WE COULD DEFINE A WORD:                                                                                                        ENTER -> : PLUS + . ;                                                                                                      A COLON ':' BEGINS THE DEFINITION, PLUS, THE NAME OF THE   WORD YOU DEFINED ABOVE. THE + . WORDS ARE EXECUTED WHEN 'PLUS'  IS INVOKED. A SEMICOLON ';' ENDS THE DEFINITION.                     REMEMBER TO SEPARATE ':' AND ';' FROM OTHER WORDS WITH     SPACES. NOTICE THAT AFTER YOU ENTERED (CR) NOTHING HAPPENED.    FORTH MERELY PUT THIS DEFINITION IN ITS DICTIONARY. LET'S 'GO'  ON TO USE THIS NEW WORD WE HAVE DEFINED.                        FRAME #39 MY WORD!                                                   TO USE THE NEW WORD 'PLUS' WHICH WE HAVE JUST CREATED:                                                                               ENTER -> 5 1 PLUS                                                                                                          UPON ENCOUNTERING THE NEW WORD 'PLUS', FORTH LOOKED IT UP  IN THE DICTIONARY, AND DETERMINED THAT THE WORDS '+' AND '.'    SHOULD BE EXECUTED.                                                                                                                  NOTICE THAT THERE IS NO DIFFERENCE IN USAGE BETWEEN A WORD WHICH YOU CREATE AND A WORD WHICH ALREADY EXISTS IN THE FORTH   DICTIONARY. AS A MATTER OF FACT, MOST OF THE WORDS IN THE       STANDARD FORTH DICTIONARY WERE CREATED USING EXACTLY THE SAME   TECHNIQUE AS WE USED FOR 'PLUS'.                                                                                                     PLEASE 'GO' ON .                                           FRAME #40 GOOD, BAD, THE UGLY                                        WE CANNOT STRESS ENOUGH THE IMPORTANCE OF USING MEANINGFUL NAMES WHEN DEFINING WORDS. THE TIME SPENT IN SELECTING RELEVANT,CONSISTENT, MEANINGFUL AND DESCRIPTIVE NAMES WILL GREATLY       SIMPLIFY YOUR PROGRAM DEBUG AND MAINTENANCE EFFORTS!                 FOR EXAMPLE, YOU MAY WANT TO IDENTIFY ALL WORDS THAT PRINT LITERALS WITH A '.' IN THE NAME. GOOD EXAMPLES:                  : .DASH ." -" ;                                                 : .BYLINE                                                         ." A FINE PRODUCT OF BOTCH, INC" ;                                BAD EXAMPLE:                                                : A-LINE ." THE STARSHIP ENTERPRISE" ;                              UGLY EXAMPLE:                                               :  TN5 ." 5" ;                                                                                                                      PLEASE 'GO' FORTH.                                         FRAME #41 REDEFINED WORDS SQUARED AWAY                               LET'S DEFINE A WORD TO SQUARE A NUMBER:                                                                                              ENTER -> : SQUARE DUP * ;                                                                                                  USING THIS WORD, WE COULD DEFINE A WORD TO CUBE A NUMBER:            ENTER -> : CUBE DUP SQUARE * ;                             NOW, SUPPOSE YOU REDEFINE SQUARE TO PRINT THE NUMBER OF    SIDES A SQUARE HAS.                                                       ENTER -> : SQUARE 4 . ;                                    HOWEVER, THIS NEW DEFINITION OF SQUARE WILL NOT AFFECT ITS USE IN THE PREVIOUSLY DEFINED WORD 'CUBE'.                                ENTER -> SQUARE                                                 ENTER -> 2 CUBE .                                          WORDS MAY BE DEFINED AND REDEFINED.                             READY TO 'GO' ON?                                          FRAME #42 A LA MODES                                                 FORTH OPERATES IN TWO MODES - EXECUTION AND COMPILATION. INEXECUTION MODE, EACH WORD OF INPUT IS LOOKED UP IN THE          DICTIONARY AND EXECUTED.                                                                                                                  ENTER -> 5 DUP . .                                                                                                         THIS EXECUTES IMMEDIATELY. DURING COMPILATION, WORDS ARE   NOT EXECUTED BUT ARE ESTABLISHED AS DEFINITIONS IN A DICTIONARY.                                                                          ENTER -> : 2FIVES 5 DUP . . ;                                                                                              ONCE THE WORD IS DEFINED (COMPILED) INTO THE DICTIONARY, ITMAY BE EXECUTED BY ENTERING ITS NAME.                                     ENTER -> 2FIVES                                            LET'S 'GO' FORTH.                                          FRAME #43 NO COMMENT!                                                WE SHOULD USE COMMENTS LIBERALLY TO ENHANCE THE READABILITYOF OUR PROGRAMS. COMMENTS MAY BE PLACED ON ANY LINE OF TEXT     BETWEEN '(' AND ')'. REMEMBER TO INCLUDE A SPACE AFTER THE LEFT PARENTHESIS, AS IT IS ACTUALLY A FORTH WORD.                         CONSIDER SOME EXAMPLES:                                                                                                     : HEAD ." INVOICE #" 5 SPACES ." QTY" ;                                ( INVOICE ) ( COLUMN HEADER)                             : CUBE DUP DUP * * ; ( CUBE A NUMBER)                                                                                                COMMENTS ARE COMMONLY USED TO INDICATE NON-OBVIOUS WORD   FUNCTIONS, EXPECTED AND RETURNED STACK CONTENTS, AS WELL AS TO  IDENTIFY PROGRAM AUTHORSHIP AND DATES.                                                                                                PLEASE 'GO' ON.                                           FRAME #44 LOOP: SEE LOOP                                             'LOOP' CAUSES A SEQUENCE OF WORDS TO BE REPEATED A         SPECIFIED NUMBER OF TIMES. A 'LOOP' MUST BE EXECUTED WITHIN A   DEFINITION. CONSIDER THE FOLLOWING EXAMPLE TO PRINT 5 NUMBERS   FROM THE STACK:                                                                                                                           ENTER -> : TAKE-FIVE 6 1 DO . LOOP ;                                                                                       'DO' STORES THE INITIAL VALUE AND LIMIT. 'LOOP' INCREMENTS THE VALUE AND BRANCHES BACK TO 'DO' UNTIL THE LIMIT IS REACHED. FOR EXAMPLE:                                                                                                                              ENTER -> 1 2 3 4 5 6 7 TAKE-FIVE                           LET'S CLEAR THE STACK:                                               ENTER -> . .                                               LET'S 'GO' ON AND LOOP AWHILE.                             FRAME #45 LOOP HOLES                                                                                                                 WE MAY ALSO DEFINE A GENERAL 'LOOP' AND SPECIFY THE NUMBER OF TIMES IT IS REPEATED AT THE TIME IT IS EXECUTED. FOR EXAMPLE,WE MAY DEFINE A WORD TO PRINT AN ASTERISK:                                                                                                ENTER -> : STARS 0 DO ." *" LOOP ;                                                                                         THEN, WE SPECIFY THE NUMBER OF TIMES WE WANT IT REPEATED BYPROVIDING THE LIMIT WHEN IT IS EXECUTED:                                                                                                  ENTER -> 15 STARS                                                                                                          PLEASE 'GO' FORTH .                                                                                                                                                                        FRAME #46 HOW DO 'I' LOOP THEE?                                      OFTEN IT IS USEFUL TO HAVE A WORD TO ACCESS THE ITERATION  COUNTER. FORTH PROVIDES IT TO YOU WITH 'I'. CONSIDER THE LOOP TOPRINT NUMBERS FROM 1 TO 10:                                                                                                               ENTER -> : TEN-#'S 11 1 DO I .                                                          LOOP ;                                  ENTER -> TEN-#'S                                                                                                           YOU GET ' 1 2 3 4 5 6 7 8 9 10'. OR, YOU MAY WAIT UNTIL    EXECUTION TIME TO DEFINE THE ITERATION COUNTER. FOR EXAMPLE:                                                                              ENTER -> : PRINT-#'S DO I . LOOP ;                              ENTER -> 11 1 PRINT-#'S                                    THIS GIVES YOU THE SAME RESULTS. MORE LOOPS ARE FORTHCOMINGSO LETS 'GO' ON.                                                FRAME #47 LIFE INSIDE A LOOP                                         SO FAR, WE HAVE DISCUSSED INCREMENTING THE 'LOOP' BY '1'.  THE FORTH WORD '+LOOP' ALLOWS DIFFERENT VALUES TO BE USED TO    ADVANCE THE COUNTER WHEN LOOPING. CONSIDER THE DEFINITION TO    PRINT ODD NUMBERS:                                                                                                                        ENTER -> : ODD 10 1 DO I .                                                          2 +LOOP ;                                                                                              THE FIRST TIME THROUGH THE LOOP, 'I' IS EQUAL TO '1' THE   STARTING VALUE OF THE LOOP. NOW, '2' IS ADDED TO THE COUNTER.   THE COUNTER IS NOW '3'. AGAIN, '2' IS ADDED UNTIL OUR LIMIT (10)IS REACHED OR PASSED. LET'S EXECUTE ODD:                                  ENTER -> ODD                                               THE RESULTS ARE '1 3 5 7 9'. LET'S 'GO' ON TO SEE ANOTHER  WAY TO USE THE '+LOOP'.                                         FRAME #48 HOW DO YOU 'DO'?                                           WE HAVE LEARNED HOW TO INCREMENT USING THE '+LOOP'. ANOTHERWAY OF USING THE '+LOOP' IS TO CALCULATE THE INCREMENT AT       EXECUTION TIME, AS IN:                                                                                                                    ENTER -> : DOUBLE 50 2 DO I .                                                          I +LOOP ;                           WHEN WE EXECUTE:                                                                                                                     ENTER -> DOUBLE                                            THE LOOP STARTS OUT BY PRINTING THE VALUE OF 'I' AND ADDINGTHAT VALUE TO THE COUNTER. EACH TIME THROUGH THE LOOP, THE      COUNTER IS PRINTED AND ADDED TO ITSELF (DOUBLED). THIS CONCLUDESOUR DISCUSSION OF THE 'DO LOOPS'. TRY A FEW EXAMPLES OF YOUR OWNTO FAMILIARIZE YOURSELF WITH THE VARIATIONS AVAILABLE.               LET'S 'GO' ON TO DISCUSS CONDITIONALS.                     FRAME #49 LIVING WITH YOUR RELATIONALS                                                                                               RELATIONAL OPERATORS TAKE VALUES FROM THE TOP OF THE STACK (TOS), TEST A RELATIONSHIP, AND LEAVE SOME RESULT ON THE STACK. A TRUE CONDITION LEAVES A '1', FALSE A '0'. THE FOLLOWING ARE   RELATIONAL OPERATORS:                                                                                                                0=   IF TOS EQUALS ZERO, IT LEAVES '1', ELSE IT LEAVES '0'      0<   IF TOS IS LESS THAN ZERO, IT LEAVES '1', ELSE '0'          NOT  A LOGICAL EQUIVALENT TO '0='.                                                                                              WE WILL SEE EXAMPLES OF THEIR USAGE LATER. LET'S 'GO' ON TOLEARN ABOUT RELATIONAL COMPARISONS.                                                                                                                                                                                                                             FRAME #50 MORE OR LESS                                               IN THE PREVIOUS SCREEN WE DISCUSSED RELATIONALS THAT TESTEDTHE TOP OF THE STACK. THE FOLLOWING RELATIONAL OPERATIONS TEST  THE TOP TWO STACK ITEMS.                                             THESE RELATIONALS REMOVE THE TOP 2 ITEMS WHICH THEY TEST,  LEAVING '1' FOR TRUE AND '0' FOR FALSE:                                                                                              <   IF THE SECOND ITEM IS LESS THAN TOS, IT LEAVES '1'          =   IF THE SECOND ITEM EQUALS TOS, IT LEAVES '1'                >   IF THE SECOND ITEM IS GREATER THAN TOS, IT LEAVES '1'                                                                  THESE COMPARISON OPERATORS FOLLOW THEIR TESTED VALUES JUST AS   THE ARITHMETIC OPERATORS DO.                                         FOR EXAMPLE: 8 6 < TESTS FOR 8 LESS THAN 6 RETURNING 0     (FALSE). 4 3 > TESTS FOR 4 GREATER THAN 3 RETURNING 1 (TRUE).   WE WILL SEE MORE OF THESE RELATIONALS USED LATER. 'GO' FORTH.   FRAME #51 BRANCHING CAN BE A PROBLEM                                 CONDITIONALS ALLOW SOME VALUE TO BE TESTED AND THE         EXECUTION TO PROCEED BASED ON THIS TEST. CONDITIONALS MUST ONLY OCCUR WITHIN A WORD DEFINITION. THEY CANNOT BE EXECUTED FROM THEKEYBOARD. THE SIMPLEST CASE INVOLVES THE 'IF' AND 'THEN'.            THE 'IF' WILL CAUSE THE WORDS BETWEEN 'IF' AND 'THEN' TO   EXECUTE PROVIDED THE TOS IS TRUE, ( NOT ZERO ). IF THE TOS IS   ZERO, FORTH WILL SKIP AHEAD TO EXECUTE THE WORDS FOLLOWING      'THEN'. FOR EXAMPLE:                                                      ENTER -> : SHOW-ME                                                         IF ." TRUE "                                                    THEN ." CONTINUE" ;                                  ENTER -> 1 SHOW-ME                                         YOU GET 'TRUE CONTINUE', SINCE TOS IS TRUE. ENTER -> 0     SHOW-ME AND YOU GET 'CONTINUE', SINCE TOS IS FALSE.                  PLEASE 'GO' ON.                                            FRAME #52 OR 'ELSE' WHAT?                                            IN THE PREVIOUS FRAME, WE SAW HOW TO SKIP AHEAD BASED ON A CERTAIN CONDITION. THE WORD 'ELSE' ALLOWS ONE OF TWO BRANCHES TOBE TAKEN. FOR EXAMPLE:                                                                                                                     ENTER -> : TRUE-FALSE                                                         IF ." TRUE "                                                    ELSE ." FALSE "                                                 THEN ." STOP " ;                                                                                            IF TOS IS TRUE, WORDS AFTER 'IF' EXECUTE; OTHERWISE WORDS  AFTER 'ELSE' EXECUTE. IN EITHER CASE, WORDS AFTER 'THEN' WILL   EXECUTE.                                                                   ENTER -> 1 TRUE-FALSE AND YOU GET 'TRUE STOP'.                  ENTER -> 0 TRUE-FALSE YOU GET 'FALSE STOP'.               'GO' ON TO DISCUSS THE NESTED 'IF'.                        FRAME #53 BRANCHING IN A NESTED 'IF'                                 LOCATING ONE CONDITIONAL WITHIN ANOTHER IS CALLED NESTING. EACH NESTING LEVEL MUST BE COMPLETELY WITHIN ANOTHER, AND MAY   NOT OVERLAP. FOR EVERY 'IF' YOU MUST HAVE A 'THEN'. CONSIDER THEFOLLOWING EXAMPLE:                                                        ENTER -> : .1ST ." FIRST " ; : .2ND ." SECOND " ;               ENTER -> : .3RD ." THIRD " ;                                    ENTER -> : NEST 5 1 ( TEST LOOP )                                               DO I 1 = IF .1ST                                                         ELSE I 2 = IF .2ND                                                ELSE I 3 = IF .3RD                                    THEN THEN THEN LOOP ;                          ENTER -> NEST                                              THIS 'LOOP' CHECKS THE ITERATION COUNTER (I). IF 'I' = '1',THEN THE WORD '.1ST' IS EXECUTED. NOTICE A 'THEN' FOR EVERY     'IF'. LETS 'GO' ON.                                             FRAME #54 UNTIL DEATH DO US PART ...                                 FORTH PROVIDES A CONDITIONAL USING 'BEGIN' AND 'UNTIL'. IT IS ESSENTIALLY A LOOP WITHOUT AN ITERATION COUNTER.                  'BEGIN' MARKS THE BEGINNING OF THE STRUCTURE. 'UNTIL' TESTSFOR A TRUE OR FALSE TOS. IF TOS IS FALSE, CONTROL IS RETURNED TO'BEGIN'. IF TRUE, THE WORDS FOLLOWING 'UNTIL' WILL EXECUTE.          FOR EXAMPLE:                                                         ENTER -> : NON-ZERO 1 ;                                         ENTER -> : ONCE BEGIN 5 . NON-ZERO UNTIL ;                      ENTER -> ONCE                                              THIS CAUSES THE WORDS BETWEEN 'BEGIN' AND 'UNTIL' TO       EXECUTE ONCE.                                                   ( IT WILL ALWAYS EXECUTE AT LEAST ONCE, AS DO THE 'LOOPS'.)     WARNING!!! IF YOU FAIL TO ALLOW A 'BEGIN' ... 'UNTIL' LOOP SOME METHOD TO TERMINATE, YOU WILL HANG THE SYSTEM! LET'S 'GO' ON TO DISCUSS BASES.                                                  FRAME #55 COVER YOUR BASES!                                                                                                          FORTH IS ABLE TO HANDLE INPUT OR OUTPUT OF NUMBERS IN ANY  BASE. THE CURRENT BASE IS EXPLICITLY CONTROLLED WITH THE        FOLLOWING WORDS.                                                                                                                     'HEX' CONVERTS NUMBERS IN BASE 16 AND 'DECIMAL' CONVERTS   NUMBERS IN BASE 10. WE CAN COMBINE BASE OPERATIONS.                                                                                  FOR EXAMPLE:                                                                                                                         ENTER -> DECIMAL 10 HEX 10 DECIMAL . .                                                                                     THIS GIVES '10' AND '16' AND A BASE TO 'GO' FORTH ON.                                                                                                                                      FRAME #56 CONSTANT COMMENTS                                                                                                          IF A VALUES FREQUENTLY USED, YOU MIGHT WANT TO NAME IT.    OFTEN, THE NAME IS EASIER TO RECALL THAN THE NUMBER ITSELF. A   'CONSTANT' IS A NAMED VALUE. LET'S DEFINE A CONSTANT TO         REPRESENT AN HOURLY PARKING RATE:                                                                                                         ENTER -> 75 CONSTANT RATE/HR                                                                                               THIS CREATES A WORD 'RATE/HR' AND ASSIGNS IT THE VALUE     '75'. USING THIS CONSTANT:                                                                                                                ENTER -> RATE/HR 3 * .                                                                                                     THIS COMPUTES A THREE HOUR PARKING RATE. LET'S 'GO' ON AND DISCUSS VARIABLES .                                             FRAME #57 'VARIABLE' CLOUDINESS                                                                                                      A VARIABLE CHANGES ITS VALUE FREQUENTLY. THE FORTH WORD    'VARIABLE' NAMES A LOCATION WHOSE VALUE IS LIKELY TO CHANGE.    CONSIDER AN EXAMPLE TO COUNT THE NUMBER OF PARKING SPACES USED:                                                                           ENTER -> 0 VARIABLE PARKING                                                                                                'PARKING' IS NOW INITIALIZED AT '0'. INVOKING A VARIABLE   PLACES ITS ADDRESS ON THE STACK. TO OBTAIN THE CONTENTS, WE USE THE FORTH WORD '@' (FETCH).                                                                                                               ENTER -> PARKING @                                                                                                         THIS PUTS THE CURRENT NUMBER OF PARKING SPACES USED ON THE TOP OF THE STACK: LET'S 'GO' ON TO DISCUSS VARIABLES FURTHER.   FRAME #58 THOSE @!?+! VARIABLES                                                                                                      SOMETIMES YOU NEED TO EXAMINE THE VALUE OF THE VARIABLE.   THE FORTH WORD '?' (QUESTION MARK) PRINTS THE CURRENT VALUE OF AVARIABLE. USING OUR PREVIOUS EXAMPLE, LET'S FIND OUT THE NUMBER OF PARKING SPACES USED:                                                                                                                   ENTER -> PARKING ?                                                                                                         WE GET '0' BECAUSE WE HAVE NOT ALTERED ITS VALUE. SUPPOSE  WE WANTED TO RESERVE 4 PARKING SPACES. WE CAN ALTER THE VARIABLEWITH THE FORTH WORD '!' (STORE).                                                                                                          ENTER -> 4 PARKING !                                                                                                       LET'S 'GO' ON TO DISCUSS OTHER 'VARIABLE' FEATURES.        FRAME #59 'PLUS' A WHOLE LOT MORE                                    WHEN INCREMENTING A VARIABLE, WE USE THE WORD '+!'         (PLUS-STORE). USING OUR PREVIOUS EXAMPLE, LET'S ADD '2' TO THE  '4' WE RESERVED:                                                                                                                          ENTER -> 2 PARKING +!                                                                                                      HOW MANY PARKING SPACES HAVE WE USED?                                                                                                ENTER -> PARKING ?                                                                                                         WE SHOULD GET '6'. THIS CONCLUDES OUR DISCUSSION OF        'CONSTANTS' AND 'VARIABLES'. IT HAS BEEN SAID, 'THE MOST COMMON MISTAKE OF INEXPERIENCED FORTH PROGRAMMERS IS EXCESSIVE USE OF  VARIABLES'. TRY TO USE THE STACK FOR VARIABLE INFORMATION AS    MUCH AS POSSIBLE! PLEASE 'GO' ON.                               FRAME #60 LESSON 2 - SUMMARY                                                                                                          WE'VE REACHED ANOTHER CONVENIENT PLACE TO STOP AND RELAX. YOU SHOULD NOW BE FAMILIAR WITH THE FOLLOWING:                                                                                   - WHAT CONSTITUTES A DEFINITION                                 - BOTH EXECUTION AND COMPILATION MODES                          - LOOPS AND CONDITIONAL LOGIC                                   - CONSTANTS AND VARIABLES                                                                                                            IF YOU DO NOT UNDESTAND ANY OF THE ABOVE CONCEPTS, 'GO' ONAND WE WILL REVIEW THE MATERIAL, OTHERWISE ENTER 'GOT-IT' AND   WE WILL PROCEED TO LESSON 3.                                                                                                                                                                                                                                    FRAME #61 LESSON 2 REVIEW                                                                                                            WE WILL REVIEW THE FRAME TITLES FOR LESSON 2. SELECT THE   TITLE WHICH IS IN THE AREA WHICH YOU WOULD LIKE TO REVIEW AND   ENTER THE FRAME NUMBER WHEN REQUESTED. THIS WILL RESTART THE    PRESENTATION ON THAT FRAME. FEEL FREE TO CREATE YOUR OWN        EXAMPLES TO HELP IN UNDERSTANDING.                                                                                                   TO REVIEW LESSON 2 TITLES:                                                                                                           ENTER -> 35 60 CONTENTS CR                                                                                                 ENTER FRAME# AND WORD 'FRAME' FOR DESIRED REVIEW POINT.                                                                                                                                                                                                    FRAME #62 LESSON 3 - ENTRY AND DISPLAY                                                                                           - RAPTURE CAPTURE                                                  (TEXT EDITOR)                                                                                                                - RAPTURE, RAPTURE, RAPTURE                                        (PRINTING UTLITIES)                                                                                                              THE OBJECTIVE OF THIS LESSON IS TO PROVIDE YOU WITH THE    TOOLS TO ENTER, EDIT AND PRINT YOUR OWN PROGRAMS.                                                                                    NOTE: UNLESS YOU ARE USING A TERMINAL WITH YOUR APPLE,     FRAMES 63 TO 77 DO NOT APPLY. THE LESSON ON THE EDITOR ONLY     APPLIES TO A SYSTEM WHICH CAN SUPPORT THE STANDARD FORTH EDITOR.APPLE-DAYTON PRO-FORTH AND AN 80-COLUMN CARD ARE FINE.               ENTER 'GO' TO PROCEED.                                     FRAME #63 SCREENS 'N THINGS                                                                                                         THE FORTH TEXT EDITOR IS DESIGNED TO ALLOW YOU TO MODIFY ANDSTORE READABLE TEXT IN SCREENS ON A DISKETTE. BRIEFLY, SOURCE   TEXT IS ENTERED VIA THE TERMINAL ON A SCREEN. A SCREEN IS       COMPRISED OF 16 LINES, EACH LINE CONTAINING 64 CHARACTERS.      THE STANDARD APPLE DISK OF 35 TRACKS AND 16 SECTORS PER         TRACK CAN CONTAIN 140 SCREENS.                                                                                                      *** PLEASE NOTE - EXAMPLES PRESENTED IN THE FOLLOWING FRAMESDEALING WITH THE EDITOR ARE FOR VIEWING AND SHOULD NOT BE       ENTERED. ***                                                                                                                        AN EXAMPLE TO DISPLAY THE CONTENTS OF SCREEN 90, WOULD BE   ENTERED AS '90 LIST'. LET'S 'GO' ON TO DISCUSS OTHER SCREEN     FEATURES.                                                       FRAME #64 WHY DO WE NEED A TEXT EDITOR?                                                                                               BECAUSE WE ARE HUMAN ( OH LUCKY COMPUTERS! ). THE TEXT    EDITOR FUNCTIONS BY MOVING A POINTER AROUND, MAKING ALL         CORRECTIONS RELATIVE TO THE POSITION OF THAT POINTER. WITHIN THEEDITOR, YOU CAN EDIT BY LINE OR BY CHARACTER. WE WILL DISCUSS   BOTH METHODS. TO INVOKE THE EDITOR, WE WOULD SIMPLY ENTER:      EDITOR (REMEMBER, DO NOT ENTER EXAMPLES DURING THE TEXT EDITOR  DISCUSSION.) WE WILL NOW 'GO' ON TO SEE HOW EDITING BY LINE     OPERATES.                                                                                                                                                                                                                                                                                                                                                                                                                                                       FRAME #65 PUT IT THERE                                                                                                               NOW THAT WE HAVE GAINED ACCESS TO THE EDITOR AND LISTED A  SCREEN, WE ARE READY TO ENTER TEXT. WE ENTER LINES (NUMBERED 0  TO 15) IN THE CURRENT SCREEN BY THE 'P' (PUT) COMMAND.                                                                               FOR EXAMPLE: 0 P ( MY FIRST LESSON) THIS COMMAND PUT LINE  NUMBER '0' ON THE TOP OF THE STACK. IT PLACED THE FOLLOWING TEXTON LINE '0' OF THE CURRENT SCREEN AND IT ALSO PLACED THAT TEXT  IN 'PAD'. (IF LINE 0 ALREADY EXISTS, THIS WILL REPLACE IT.)     'PAD' IS A 64 CHARACTER BUFFER AREA USED WHEN WE REPLACE,       INSERT, OR DELETE LINES. WE WILL 'GO' ON AND DISCUSS 'PAD'      FURTHER IN OUR LATER SCREENS.                                                                                                                                                                                                                                   FRAME #66 'T' TIME                                                   THE EDITOR WORD 'T' (TYPE) IS USED TO DISPLAY A LINE. 'T'  IS SPECIFICALLY DESIGNED TO BE USED IN CONJUNCTION WITH 'P' IN  MODIFYING A PREVIOUSLY ENTERED LINE. WHEN THE 'T' COMMAND IS    ENTERED, IT INDENTS 2 SPACES BEFORE PRINTING YOUR NEXT TERMINAL LINE, LEAVING ROOM FOR A 'P' AND A SPACE, ALIGNING CORRECTIONS. FOR EXAMPLE:                                                                                                                              0 T ( MY FIRST LESSON)                                                                                                     NOW TO MODIFY THAT LINE, WE WOULD ENTER DIRECTLY BENEATH   IT:                                                                                                                                       0 P ( MY FIRST FORTH LESSON)                                                                                               LET'S 'GO' ON TO INSERT AND DELETE LINES.                  FRAME #67 NOW YOU SEE IT                                                                                                             THE EDITOR WORD 'D' (DELETE) IS USED TO DELETE A LINE. FOR EXAMPLE, TO DELETE LINE 3 YOU WOULD ENTER:                                                                                                 3 D                                                                                                                       THIS COMMAND PLACES LINE 3 IN 'PAD', MOVES THE SUCCEEDING  LINES IN THE SCREEN UP, AND RENUMBERS THE LINES FROM 0 TO 15.                                                                        IT IS IMPORTANT TO NOTE, THAT LINE 15 REMAINS THE SAME AND IS NOT BLANKED. NEVER USE THE 'D' COMMAND ON LINE 15, USE 'P' OR'R' (WHICH WILL BE DISCUSSED LATER). NOW THAT WE CAN DELETE A   LINE, LET'S 'GO' ON TO DISCUSS INSERTS.                                                                                                                                                         FRAME #68 THE I'S HAVE IT                                                                                                            THE EDITOR WORD 'I' (INSERT) INSERTS THE LINE IN 'PAD'. ON OUR PREVIOUS EXAMPLE, WE DELETED LINE 3. IT STILL EXISTS IN     'PAD', HOWEVER. LET'S LOOK AT AN EXAMPLE TO EXCHANGE LINES 3 AND4:                                                                                                                                        3 D 4 I                                                                                                                    THIS PUTS LINE 3 IN 'PAD', MOVES THE SUCCEEDING LINES UP   ONE, AND INSERTS THE CONTENTS OF 'PAD' (OLD LINE 3) BEFORE THE  NEW LINE 4. REMEMBER, THE LINE NUMBER REFERS TO THE CURRENT     POSITION OF A LINE WITHIN A SCREEN.                                                                                                  PLEASE 'GO' ON.                                                                                                            FRAME #69 THERE'S NO PLACE LIKE REPLACE                                                                                              THE EDITOR WORD 'R' (REPLACE) WILL REPLACE THE LINE WHOSE  NUMBER IS ON THE STACK BY THE CONTENTS OF 'PAD'. FOR EXAMPLE, TOMAKE LINES 5 AND 6 IDENTICAL WE WOULD ENTER:                                                                                              5 T 6 R                                                                                                                    SUPPOSE WE WANTED TO BLANK OUT LINES 1 THROUGH 3:                                                                                    1 P                                                             2 R 3 R                                                                                                                    THE 'P' COMMAND PUT BLANKS IN LINE 1 AND 'PAD'. WE THEN    REPLACED LINES 2 AND 3 WITH THE CONTENTS OF'PAD'.                    PLEASE 'GO' ON.                                            FRAME #70 BETWEEN THE LINES                                                                                                          THE EDITOR ALSO HAS THE ABILITY TO INSERT A BLANK LINE IN  FRONT OF ANY LINE ON THE SCREEN WITH THE COMMAND 'S' (SPACE). TOADD A BLANK LINE BEFORE LINE 5 THE FOLLOWING IS ENTERED:                                                                                  5 S                                                                                                                        NOW A BLANK LINE EXISTS PRIOR TO LINE 5 AND ALL SUCCEEDING LINES HAVE BEEN MOVED DOWN ONE, PUSHING LINE 15 OFF THE SCREEN.                                                                                                                                                                                                      THAT'S ALL OF THE ESSENTIAL COMMANDS.                                                                                           TYPE 'GO' TO PROCEED TO THE SUMMARY.                       FRAME #71 I'VE HEARD THAT LINE BEFORE                                                                                                IN SUMMATION, THE VOCABULARY FOR EDITING LINES INCLUDES THEFOLLOWING WORDS:                                                                                                                 N P   (TEXT) PUTS TEXT INTO 'PAD' AND LINE N.                   N T   COPIES LINE N INTO 'PAD', TYPES IT, AND LEAVES LINE N ON        THE STACK.                                                N R   REPLACES LINE N BY THE CONTENTS OF 'PAD'.                 N D   COPIES LINE N INTO 'PAD' AND DELETES IT.                  N I   INSERTS CONTENTS OF 'PAD' BEFORE LINE N.                  N S   ADDS A BLANK LINE BEFORE LINE N. MOVES ALL SUCCEEDING           LINES DOWN ONE.                                                                                                               READY TO 'GO' ON TO DISCUSS THE CHARACTER EDIT COMMANDS?                                                                   FRAME #72 WHAT'S THE POINT?                                                                                                          WITHIN THE EDITOR, THERE ARE ALSO WORDS FOR EDITING        CHARACTERS. THE CHARACTER EDITING COMMANDS OPERATE ON STRINGS   WITHIN A SELECTED LINE. A CHARACTER POINTER REMINDS YOU OF YOUR POSITION ON A SPECIFIC LINE. ALL COMMANDS ARE DONE RELATIVE TO  THAT POINTER POSITION. THE COMMAND 'TOP' POSITIONS THE CHARACTERPOINTER AT THE BEGINNING OF THE SCREEN. FOR EXAMPLE: TOP                                                                             AND NOW WE ARE READY TO 'GO' ON TO CHARACTER EDITING.                                                                                                                                                                                                                                                                                                                                                                                                      FRAME #73 'FIND'ERS KEEPERS (NOT USED IN THIS VERSION)               THE 'F' (FIND) COMMAND FINDS THE NEXT OCCURRENCE OF A      STRING AFTER THE CURRENT POINTER POSITION. IT PRINTS THE LINE ONWHICH IT OCCURS AND POSITIONS THE POINTER AFTER THE STRING.     LET'S LOOK AT A SAMPLE LINE:                                                                                                              I WANT TO BE A PROGRAMMER                                                                                                  SUPPOSE WE WANTED TO MOVE THE POINTER BEFORE PROGRAMMER.   (FOR THE FOLLOWING EXAMPLES, THE UNDERSCORE REPRESENTS THE      CURRENT POINTER POSITION.) WE WOULD ENTER: F A. BUT, SINCE      THERE IS ANOTHER 'A', WE WOULD GET:                                       I WA_NT TO BE A PROGRAMMER                                 TO FIND THE NEXT 'A' WE USE THE 'N' (NEXT) COMMAND: N                I WANT TO BE A_ PROGRAMMER                                 NOW PLEASE 'GO' ON.                                        FRAME #74 CURRENT EVENTS                                                                                                             THE 'C' COMMAND INSERTS TEXT AT THE CURRENT POINTER        POSITION. USING OUR PREVIOUS EXAMPLE:                                     I WANT TO BE A_ PROGRAMMER                                                                                                 WE CAN INSERT THE FOLLOWING:                                                                                                         C  FORTH                                                                                                                   THIS WILL GIVE US:                                                   I WANT TO BE A FORTH_ PROGRAMMER                                                                                           NOW THAT WE CAN INSERT STRINGS, LET'S 'GO' ON TO DELETE    STRINGS.                                                                                                                        FRAME #75 PULLING YOUR OWN STRINGS                                   THE 'X' COMMAND FINDS AND DELETES A STRING FROM THE SCREEN AFTER THE CURRENT POINTER POSITION. USING AN EXAMPLE:                                                                                FORTH IS EASY AS CAKE                                                                                                                ENTERING:  X EASY AS                                       WOULD GIVE US:     FORTH IS _ CAKE                              ANOTHER DELETE WORD 'TILL' DELETES ALL CHARACTERS THROUGH  AND INCLUDING THE STRING BEGINNING AT THE CURRENT POINTER       POSITION (WITHIN THE CURRENT LINE). FOR EXAMPLE:                          ENTERING:  TILL CAKE                                       WOULD GIVE US:     FORTH IS _                                                                                                   THIS CONCLUDES OUR CHARACTER EDITING COMMANDS. LET'S 'GO'  ON AND SUMMARIZE WHAT WE HAVE LEARNED.                          FRAME #76 UNFORGETTABLE CHARACTERS                                   F (TEXT) FINDS THE NEXT OCCURRENCE OF 'TEXT' AFTER THE            CURRENT POINTER POSITION. PRINTS LINE # ON WHICH IT             OCCURS, AND POSITIONS THE POINTER AFTER 'TEXT'.               N FINDS THE NEXT OCCURRENCE OF 'TEXT' (USED AFTER 'F')            PRINTS LINE # AND POSITIONS THE POINTER AFTER 'TEXT'.         C (TEXT) INSERTS 'TEXT' AT CURRENT POINTER POSITION.            X (TEXT) FINDS & DELETES 'TEXT' FROM THE CURRENT SCREEN           BEGINNING AT THE CURRENT POINTER POSITION.                 TILL (TEXT) DELETES ALL CHARACTERS THROUGH & INCLUDING               'TEXT' STARTING AT THE CURRENT POINTER POSITION.                (ONLY OPERATES WITHIN THE CURRENT LINE)                                                                                  DON'T FORGET THAT YOU CAN USE THE APPLE'S "ESCAPE" COMMANDS     TO EDIT ON THE SCREEN JUST YOU WOULD IN BASIC.                      TYPE 'GO' TO CONTINUE                                       FRAME #77 SOS (SAVE OUR SCREEN)                                      HOW DO WE SAVE THE CONTENTS OF OUR SCREEN? TO TRANSFER ALL YOUR CHANGES OUT TO DISKETTE, ENTER:                                      FLUSH                                                      THIS IS MOST IMPORTANT BEFORE REMOVING A DISKETTE, SHUTTINGDOWN YOUR SYSTEMS, OR BEFORE YOUR SYSTEM SHUTS YOU DOWN!             ALTHOUGH FORTH WILL EVENTUALLY SAVE YOUR CHANGES, A SYSTEM CRASH MAY CAUSE THEM TO BE LOST.                                     WE CAN ALSO COPY AN ENTIRE SCREEN TO ANOTHER TO MODIFY IT  WITHOUT DESTROYING THE ORIGINAL. FOR EXAMPLE, TO COPY SCREEN 80 TO SCREEN 90, ENTER:                                                      80 90 COPY                                                 TO LEAVE THE EDITOR, WE SIMPLY ENTER:                                FORTH                                                                                                                      PLEASE 'GO' ON.                                            FRAME #78 PRINTS CHARMING                                                                                                            THE FORTH PRINTING UTILITY ALLOWS YOU TO DISPLAY SOURCE    TEXT AND TO GENERATE AN INDEX TO YOUR LISTINGS. THUS FAR, WE    HAVE DISCUSSED VARIOUS WAYS OF ENTERING AND PRINTING DATA. THEREARE A COUPLE OF WAYS TO PRINT PROGRAMS.                                                                                          TRIAD    PRINTS A GROUP OF THREE SCREENS                                                                                         SHOW    PRINTS MULTIPLE THREE SCREEN GROUPS                                                                                    INDEX    PRINTS THE FIRST LINE OF A RANGE OF SCREENS                                                                                LET`S 'GO' ON TO DISCUSS 'TRIAD'.                                                                                                                                                          FRAME #79 THREE'S COMPANY                                                                                                            YOU WILL DISCOVER THAT THREE SCREENS OF FORTH SOURCE FIT   COMFORTABLY ON AN 8 1/2 BY 11 INCH SHEET OF PAPER. THIS IS THE  PRIMARY REASON FOR THE CUSTOMARY GROUPING OF FORTH SOURCE       STATEMEMTS ONTO BOUNDRIES OF THREE SCREENS. A SECONDARY REASON  IS THAT ONE IS ENCOURAGED TO SAVE PAPER AND TIME NORMALLY SPENT GENERATING LARGE LISTINGS IN WHICH A ONLY A FEW STATEMENTS WERE CHANGED. IN FORTH, YOU ONLY REPRINT THE PAGE ON WHICH THE CHANGEWAS MADE. THIS IS THE FUNCTION OF THE WORD 'TRIAD'. CONSIDER AN EXAMPLE TO PRINT THE TRIAD CONTAINING SCREEN #20:                                                                                         20 TRIAD                                                                                                                   LET'S 'GO' ON TO DISCUSS MULTIPLE PAGE PRINTING.                                                                           FRAME #80 A REALLY BIG 'SHOW'                                                                                                        WE HAVE THUS FAR DISCUSSED PRINTING A FEW SELECTED SCREENS.SUPPOSE WE WANT TO PRINT A LARGE RANGE OF SCREENS. THE FORTH    WORD 'SHOW' HANDLES THIS. CONSIDER AN EXAMPLE TO PRINT ALL      SCREENS FROM 100 THROUGH 150:                                                                                                             100 150 SHOW                                                                                                               THIS 'SHOW' COMMAND WILL GENERATE ALL TRIADS NECESSARY TO  SHOW THE RANGE OF SCREENS FROM 100 THROUGH 150, INCLUSIVE. SO   NOW WE CAN PRINT ENTIRE SCREENS, BUT HOW DO WE PRINT PART OF    ONE? LET'S 'GO' ON.                                                                                                             (IN THIS SYSTEM 'SHOW' HAS BEEN REPLACED BY 'PLIST' FOUND ON    (THE MASTER DISK. IT WORKS WITH MOST PRINTERS IN SLOT 1.)       FRAME #81 THE IN'S AND OUT'S OF 'INDEX'                                                                                              EARLIER IN THIS SESSION, WE DISCUSSED SOME WAYS TO ORGANIZEOUR SCREENS. WE MENTIONED THE FORTH CONVENTION OF PLACING A     BRIEF DESCRIPTIVE COMMENT ON LINE 0 OF EVERY SCREEN. NOW WE WILLSEE WHY THIS WAS SUCH A HOT IDEA! THE FORTH 'INDEX' COMMAND     PRINTS THE FIRST LINE (LINE 0) ALONG WITH THE SCREEN NUMBER, OF SELECTED SCREENS. SO IT FOLLOWS, IF LINE 0 CONTAINS A           DESCRIPTION OF THAT SCREEN, WE NOW HAVE AN ORGANIZED 'INDEX' OF OUR SCREENS.                                                                                                                         LET'S 'GO' ON TO SEE HOW WE USE THIS COMMAND.